import router from '@/router';

/**
 * @exports ISJSON 判断数据是否位JSON
 * @param param 需要判读的值
 * @returns true=> 为JSON、false =>不是JSON
 */
export const ISJSON = (param: unknown) => {
  if (typeof param == 'string') {
    const obj = JSON.parse(param);
    if (typeof obj == 'object' && obj) {
      return true;
    } else {
      return false;
    }
  } else {
    return false;
  }
};

/**
 * @exports phoneFormat 手机号码格式化
 * @param param 输入手机号码
 * @returns 返回格式化后的内容
 */
export const phoneFormat = (param: any) => {
  if (param == null || param == '') {
    return '';
  }
  const mun = param.split('');
  mun.splice(3, 0, ' ');
  mun.splice(8, 0, ' ');
  return mun.join('');
};

/**
 * @exports deepCopy 深拷贝
 * @param param 需要copy的值
 * @returns 返回拷贝完的数据
 */
export const deepCopy = (param: any) => {
  return JSON.parse(JSON.stringify(param));
};
/**
 * @exports isNullPm 判断数据,用来判断是否 == '' | == undefined | == null
 * @param param      需要判断的数据
 * @param zero       是否开启对 0 的审核 , true => 开启 | false => 关闭 , 默认为false
 * @returns          当数据为 == '' | == undefined | == null return=>true,否则返回 return =>false
 */
export const isNullPm = (param: any, zero = false) => {
  let state = false;
  if (param === '' || param === undefined || param === null || param === 'null') state = true;
  if (zero && (param === 0 || param === '0')) state = true;
  return state;
};

/**
 * @exports isJSON 判断是否为JSON
 * @param param
 * @returns true = > 数据为JSON , false => 数据不为JSON
 */
export const isJSON = (param: any) => {
  if (typeof param == 'string') {
    try {
      const obj = JSON.parse(param);
      if (typeof obj == 'object' && obj) {
        return true;
      } else {
        return false;
      }
    } catch (e) {
      return false;
    }
  } else {
    return false;
  }
};


/**
 * @exports queryDataFilter 配合表单数据转化有效的查询字段
 * @param param
 */
export const queryDataFilter = (param: any) => {
  return param.filter((res: any) => {
    if (!isNullPm(res.value)) {
      return res;
    }
  });
};

/**
 * @exports getInitParam 拼接参数配合 queryDataFilter 使用
 * @param param
 */
export const getInitParam = (param: any) => {
  const steam: any = [];
  param.map((res: any) => {
    const ste = {
      [res.key]: res.value,
    };
    steam.push(ste);
  });
  return steam;
};

/**
 * @exports GetParamJoIn GET请求拼接参数使用,用axios自带的GET请求添加不了参数,只能把数据拼上去
 * @param param Object对象,传进来参数必须是Objeck
 * @returns   返回的是拼接好的字符串值:string,eg '?id=11&&name=22'
 */
export const GetParamJoIn = (param: any) => {
  let d = '?';

  if (param == '' || param == void 0) {
    return '';
  } else {
    /**
     * b    ---->传进来的param对象
     * d    ---->拼接的字符串
     */
    const b: any = Object.keys(param);
    if (b.length !== 0 || b !== undefined || b !== '') {
      for (let c: any = 0; c < b.length; c++) {
        /**
         * `${c === b.length - 1 ? '' : '&&'}` 最后一个参数不添加&
         */
        d += b[c] + '=' + param[b[c]] + `${c === b.length - 1 ? '' : '&'}`;
      }
    }
  }
  return d;
};
/**
 * @exports isParam 判断数组是否存在某个值
 * @param param 传入的数组
 * @param paramKey 传入的数组 param 相对应的标识符
 * @param key 传入的key
 * @returns  state.state 存在 => true | 不存在 => false , state.value 对应的值 ,state.index  对应的下标
 */
export const isParam = (param: Array<any>, paramKey: string, key: string | number) => {
  const state: any = {
    state: false,
    value: '',
    index: null,
  };
  param.some((res: any, index): any => {
    if (res[paramKey] == key) {
      state.state = true;
      state.value = res;
      state.index = index;
      return state;
    }
  });
  return state;
};

/**
 * @exports routerJump router跳转新页面的方法
 * @param path 跳转路径
 * @param type 跳转时的query参数  当参数为link 时获取跳转的链接
 * @param typeA 传link 获取当前跳转的链接。
 */
export const routerJump = (path: any, type?: any, typeA?: string): string | void => {
  // resolve新窗口打开
  const newpage = router.resolve({
    path: path, // 跳转的页面路由
    query: {
      // 要传的参数
      ...type,
    },
  });
  if (typeA == 'link') {
    return window.location.origin + newpage.href;
  } else {
    window.open(newpage.href, '_blank'); // 打开新的窗口(跳转路径，跳转类型)
  }
};

/**
 * @exports  arrayStatistics  数组统计相同数据
 * @param param 需要统计的数组
 * @returns 返回统计完成的数组  mumList.label 数据名称
 *                             mumList.num 数据数量
 */
export const arrayStatistics = (param: Array<any>) => {
  const mumList: any = [];

  if (param.length > 0) {
    const newList = [...new Set(param)];
    newList.map((res: any) => {
      let num = 0;
      param.map((reb: any) => {
        if (reb == res) {
          num++;
        }
      });
      mumList.push({
        label: res,
        num: num,
      });
    });
  }
  return mumList;
};

/**
 * @exports formatDate 时间转化格式
 * @param date 时间
 * @param format 时间输出格式
 * 格式说明
 * 对于 2014.09.05 13:14:20
 * yyyy: 年份，2014
 * yy: 年份，14
 * MM: 月份，补满两位，09
 * M: 月份, 9
 * dd: 日期，补满两位，05
 * d: 日期, 5
 * HH: 24制小时，补满两位，13
 * H: 24制小时，13
 * hh: 12制小时，补满两位，01
 * h: 12制小时，1
 * mm: 分钟，补满两位，14
 * m: 分钟，14
 * ss: 秒，补满两位，20
 * s: 秒，20
 * w: 星期，为 [‘日’, ‘一’, ‘二’, ‘三’, ‘四’, ‘五’, ‘六’] 中的某一个
 * @returns
 */
export const formatDate = (date: any, format: any) => {
  const addZero = (data: any) => {
    if (data < 10) {
      return '0' + data;
    }
    return data;
  };
  const obj: any = {
    yyyy: date.getFullYear(),
    yy: date.getFullYear() % 100,
    MM: addZero(date.getMonth() + 1),
    M: date.getMonth() + 1,
    dd: addZero(date.getDate()),
    d: date.getDate(),
    HH: addZero(date.getHours()),
    H: date.getHours(),
    hh: addZero(date.getHours() % 12),
    h: date.getHours() % 12,
    mm: addZero(date.getMinutes()),
    m: date.getMinutes(),
    ss: addZero(date.getSeconds()),
    s: date.getSeconds(),
    w: (function () {
      const arr = ['日', '一', '二', '三', '四', '五', '六'];
      return arr[date.getDay()];
    })(),
    WW: (function () {
      const arr = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
      return arr[date.getDay()];
    })(),
  };
  for (const i in obj) {
    format = format.replace(i, obj[i]);
  }
  return format;
};

/**
 * @exports getDateStr 通过给定的时间 推算结束日期
 * @param time 起始时间 EG：2022-08-06
 * @param day 天数
 * @returns
 */
export const getDateStr = (time: any, day: any) => {
  const dd = new Date(time);
  dd.setDate(dd.getDate() + (Number(day) - 1)); //获取AddDayCount天后的日期
  return formatDate(dd, 'yyyy-MM-dd');
};

/**
 * @spaceTime 时间差计算工具
 * @param startTime
 * @param endTime
 * @returns
 */
export const spaceTime = (startTime: any, endTime: any) => {
  //startTime和endTime是2006-12-18格式
  let dateSpan: any = null,
    dates: any = null;
  startTime = Date.parse(startTime);
  endTime = Date.parse(endTime);
  dateSpan = endTime - startTime;
  // dateSpan = Math.abs(dateSpan);
  dates = Math.floor(dateSpan / (24 * 3600 * 1000));
  return dates;
};

/**
 * @exports EFTimeFormatConversion 易飞专属时间格式转化工具
 * @param param
 * @returns
 */
export const EFTimeFormatConversion = (param): any => {
  if (isNullPm(param)) return param;
  if (param.length > 4) return param.substring(0, 4) + '-' + param.substring(4, 6) + '-' + param.substring(6, 8);
  else return param.substring(0, 2) + '-' + param.substring(2, 5);
};

/**
 * @exports isTimeInInterval 判断传入的时间是否在时间区间内
 * @param startTime 起始时间
 * @param endTime 结束时间
 * @param currentTime 需要判断的时间
 * @returns
 */
export const isTimeInInterval = (startTime, endTime, currentTime) => {
  if (isNullPm(startTime) || isNullPm(endTime) || isNullPm(currentTime)) return false;
  const start = new Date(startTime);
  const end = new Date(endTime);
  const current = new Date(currentTime);
  console.log(`起始时间:${start},结束时间:${end},当前选定时间:${current} `);
  return current >= start && current <= end;
};
/**
 * @exports debounce 防抖代码
 * @param func
 * @param delay
 * @returns
 */
export function debounce<T extends (...args: any[]) => void>(func: T, delay: number) {
  let timeoutId: any = null;
  return function (this: ThisParameterType<T>, ...args: Parameters<T>) {
    const context = this;
    const later = () => {
      timeoutId = null;
      func.apply(context, args);
    };
    clearTimeout(timeoutId);
    timeoutId = setTimeout(later, delay);
  };
}
